#include "Initialisierungen.h"
#include "Spieldefinitionen.h"
#include "Technisches.h"

#include <iostream>
#include <sstream>
#include <algorithm>

std::vector<int> extractNumbersFromString(std::string line, char seperator)
{
	std::replace(std::begin(line), std::end(line), seperator, ' ');

	std::stringstream ss;
	ss << line;

	std::vector<int> result;
	int tmp;
	while ( ss >> tmp )
		result.push_back(tmp);

	return result;
}

Vector2Dim<int>::value_type leseStarthandkartenEin()
{
	// welche Karten hat der Spieler? Diese ausfragen
	std::cout << "Welche Karten hast du?" << std::endl;

	std::cout << std::endl << "Liste mit Zimmern" << std::endl;
	for(std::size_t i = 0; i < Zimmer::COUNT; ++i)
		std::cout << i << ".- " << getZimmerString(static_cast<Zimmer::EZimmer>(i)) << std::endl;
	std::cout << "Gib alle Kartennummern ein, die du hast (durch Komma getrennt): ";
	std::string zimmerNummern;
	std::getline(std::cin, zimmerNummern);

	std::cout << std::endl << "Liste mit Waffen" << std::endl;
	for(std::size_t i = 0; i < Waffe::COUNT; ++i)
		std::cout << i << ".- " << getWaffeString(static_cast<Waffe::EWaffe>(i)) << std::endl;
	std::cout << "Gib alle Kartennummern ein, die du hast (durch Komma getrennt): ";
	std::string waffenNummern;
	std::getline(std::cin, waffenNummern);

	std::cout << std::endl << "Liste mit Personen" << std::endl;
	for(std::size_t i = 0; i < Figur::COUNT; ++i)
		std::cout << i << ".- " << getFigurString(static_cast<Figur::EFigur>(i)) << std::endl;
	std::cout << "Gib alle Kartennummern ein, die du hast (durch Komma getrennt): ";
	std::string figurenNummern;
	std::getline(std::cin, figurenNummern);

	Vector2Dim<int>::value_type ergebnisVec(ObjektArt::COUNT);

	ergebnisVec[static_cast<std::size_t>(ObjektArt::Zimmer)] = extractNumbersFromString(zimmerNummern);
	ergebnisVec[static_cast<std::size_t>(ObjektArt::Figur)] = extractNumbersFromString(figurenNummern);
	ergebnisVec[static_cast<std::size_t>(ObjektArt::Waffe)] = extractNumbersFromString(waffenNummern);

	return ergebnisVec;
}

std::vector<int> leseAuswahlAnKombinationEin(std::vector<std::map<int, double>> const& v)
{
	std::size_t i = 0;

	while ( i < Zimmer::COUNT || i < Waffe::COUNT || i < Figur::COUNT )
	{
		auto tmpFlags = std::cout.flags();

		std::cout.width(25);
		std::cout.flags(std::ios::left);
		if ( i < Zimmer::COUNT )
		{
			std::stringstream ss;
			ss << i << ".- " << getZimmerString(static_cast<Zimmer::EZimmer>(i));
			ss << "(" << v[ObjektArt::Zimmer].at(i) << ")";
			std::cout << ss.str();
		}
		std::cout.width(25);
		std::cout.flags(std::ios::left);
		if ( i < Figur::COUNT )
		{
			std::stringstream ss;
			ss << i << ".- " << getFigurString(static_cast<Figur::EFigur>(i));
			ss << "(" << v[ObjektArt::Figur].at(i) << ")";
			std::cout << ss.str();
		}
		std::cout.width(25);
		std::cout.flags(std::ios::left);
		if ( i < Waffe::COUNT )
		{
			std::stringstream ss;
			ss << i << ".- " << getWaffeString(static_cast<Waffe::EWaffe>(i));
			ss << "(" << v[ObjektArt::Waffe].at(i) << ")";
			std::cout << ss.str();
		}
		std::cout << std::endl;
		++i;

		std::cout.width(0);
		std::cout.flags(tmpFlags);
	}

	int waffe, figur, zimmer;

	std::cout << "Zimmer: ";
	//std::cin >> zimmer;
	zimmer = readNumber<int>(std::cin, 0, Zimmer::COUNT);

	std::cout << "Figur: ";
	//std::cin >> figur;
	figur = readNumber<int>(std::cin, 0, Figur::COUNT);

	std::cout << "Waffe: ";
	//std::cin >> waffe;
	waffe = readNumber<int>(std::cin, 0, Waffe::COUNT);

	std::vector<int> ergebnis(ObjektArt::COUNT);
	ergebnis[ObjektArt::Zimmer] = zimmer;
	ergebnis[ObjektArt::Figur] = figur;
	ergebnis[ObjektArt::Waffe] = waffe;

	return ergebnis;
}

VektorMapIntDouble initializeBekannteKarten()
{
	VektorMapIntDouble vec(ObjektArt::COUNT);
	
	for(std::size_t f = 0; f < Figur::COUNT; ++f)
		vec[ObjektArt::Figur][f] = 1.0;

	for(std::size_t w = 0; w < Waffe::COUNT; ++w)
		vec[ObjektArt::Waffe][w] = 1.0;

	for(std::size_t z = 0; z < Zimmer::COUNT; ++z)
		vec[ObjektArt::Zimmer][z] = 1.0;

	return vec;
}


void verarbeiteSpielerEingabe(VektorMapIntDouble & v, std::vector<int> const& eingabe)
{
	for(std::size_t i = 0;  i < eingabe.size(); ++i)
	{
		v[i][eingabe[i]] *= 0.5;
	}
}

std::vector<int> empfehlung(VektorMapIntDouble const& v)
{
	std::vector<int> result(ObjektArt::COUNT);


	for(std::size_t i = 0; i < v.size(); ++i)
	{
		auto erg = *std::max_element(std::begin(v[i]), std::end(v[i]), 
			[](decltype(*std::begin(v[i])) a, decltype(*std::begin(v[i])) b)
		{
			return a.second < b.second;
		}
			);
		result[i] = erg.first;
	}

	return result;
}

